﻿using DB;
using Models;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Elixi_AntdUi
{
    public partial class SelectRFID : Form
    {
        // （可选）定义有效传感器ID的匹配规则（与HFReader内部ParseSensorData规则一致，确保解析逻辑统一）
        private const string SensorIdPattern = @"E[0-9A-Fa-f]{15}"; // E开头+15位十六进制（共16位）

        // 声明事件
        public event Action<List<string>> OnSensorDataReady;
        // 在类级别声明事件（使用标准的EventHandler模式）
        public event EventHandler<string> OnSensorsParsedString;


        public string text_SensorID1 = string.Empty;
        public string text_SensorID2 = string.Empty;

        public SelectRFID()
        {
            InitializeComponent();

            OnSensorDataReady += HandleSensorData;

        }
        private void SubscribeToSensorEvents()
        {
            // 订阅传感器字符串事件
            OnSensorsParsedString += HandleSensorStringData;
        }
        private void btn_select_Click(object sender, EventArgs e)
        {

        }

        private void btn_up_Click(object sender, EventArgs e)
        {
          
            Console.WriteLine("点击上传按钮，等待传感器数据...");
            /* // 1. 订阅事件（确保只订阅一次）
             // 使用 -= 先取消订阅，再重新订阅，避免重复订阅
             OnSensorDataReady -= HandleSensorData;
             OnSensorDataReady += HandleSensorData;

             Console.WriteLine("已订阅传感器数据事件");*/
            OnSensorDataReady -= HandleSensorData;
            OnSensorDataReady += HandleSensorData;

        }

        private void HandleSensorStringData(object sender, string sensorString)
        {
            // 跨线程安全处理
            if (this.InvokeRequired)
            {
                this.Invoke(new EventHandler<string>(HandleSensorStringData), sender, sensorString);
                return;
            }

            Console.WriteLine($"收到传感器字符串广播: {sensorString}");
            textBox_RFID1.Text = "1";

        }
        private void HandleSensorData(List<string> sensors)
        {
            if (this.InvokeRequired)
            {
                this.Invoke(new Action<List<string>>(HandleSensorData), sensors);
                return;
            }

            Console.WriteLine($"收到传感器数据，数量: {sensors.Count}");
            foreach (var sensor in sensors)
            {
                Console.WriteLine($"传感器ID: {sensor}");
            }

            // 日志输出当前UI值
            Console.WriteLine($"UI控件更新：text_SensorID1={text_SensorID1}, text_SensorID2={text_SensorID2}");
        }
       
        private void HandleSensorData_111(List<string> sensors)
        {
            // 注意：这里需要跨线程安全更新UI
            if (this.InvokeRequired)
            {
                this.Invoke(new Action<List<string>>(HandleSensorData), sensors);
                return;
            }

            Console.WriteLine($"收到传感器数据，数量: {sensors.Count}");
            /* foreach (var sensor in sensors)
             {
                 Console.WriteLine($"传感器ID: {sensor}");
             }*/
            // 清空旧值
            text_SensorID1 = string.Empty;
            text_SensorID2 = string.Empty;

            // 赋值新值（1个或2个ID）
            if (sensors.Count >= 1)
            {
                text_SensorID1 = sensors[0];
                textBox_RFID1.Text = text_SensorID1;
            }
            if (sensors.Count >= 2)
            {
                text_SensorID2 = sensors[1];
                textBox_RFID1.Text = text_SensorID1;
            }

            // 日志输出当前UI值
            Console.WriteLine($"UI控件更新：text_SensorID1={text_SensorID1}, text_SensorID2={text_SensorID2}");

        }
        /// <summary>
        /// 同步更新传感器ID到UI控件（避免直接在解析方法中耦合UI操作）
        /// </summary>
        private void UpdateSensorUIControls(List<string> sensors)
        {
            // 确保在UI线程操作控件
            if (InvokeRequired)
            {
                Invoke(new Action<List<string>>(UpdateSensorUIControls), sensors);
                return;
            }

            // 清空旧值
            text_SensorID1 = string.Empty;
            text_SensorID2 = string.Empty;

            // 赋值新值（1个或2个ID）
            if (sensors.Count >= 1)
            {
                text_SensorID1 = sensors[0];
                textBox_RFID1.Text = text_SensorID1;
            }
            if (sensors.Count >= 2)
            {
                text_SensorID2 = sensors[1];
                textBox_RFID1.Text = text_SensorID1;
            }

            // 日志输出当前UI值
            Console.WriteLine($"UI控件更新：text_SensorID1={text_SensorID1}, text_SensorID2={text_SensorID2}");
        }

        private void btn_clear_Click(object sender, EventArgs e)
        {

            if (!string.IsNullOrWhiteSpace(textBox_TagID.Text) || !string.IsNullOrWhiteSpace(textBox_RFID1.Text) || !string.IsNullOrWhiteSpace(textBox_RFID2.Text))
            {
                textBox_RFID1.Clear();
                textBox_RFID2.Clear();
                textBox_TagID.Clear();
                MessageBox.Show("1");
            }
            else if (string.IsNullOrWhiteSpace(textBox_TagID.Text) && string.IsNullOrWhiteSpace(textBox_RFID1.Text) && string.IsNullOrWhiteSpace(textBox_RFID2.Text))
            {
                this.Dispose();
            }
            else
            {
                MessageBox.Show("3");
            }

        }



        private void OnForm2DataUpdated(string receivedData)
        {
            // 1. 跨线程安全校验（保留你的原有逻辑，确保UI操作安全）
            if (this.InvokeRequired)
            {
                this.Invoke(new Action<string>(OnForm2DataUpdated), receivedData);
                return;
            }

            // 2. （新增）日志追踪：明确接收的数据内容（便于排查“是否收到空数据”）
            Console.WriteLine($"[Form1-数据接收] 原始推送数据：{receivedData ?? "null/空字符串"}");

            // 3. （核心修复）提取有效传感器ID（与HFReader内部规则对齐，避免无效数据干扰）
            List<string> validSensorIds = ExtractValidSensorIds(receivedData);

            // 4. （核心）根据有效ID数量，同步更新UI（空数据/无有效ID时主动清空）
            UpdateSensorUI(validSensorIds);

            // 5. 保留你的原有业务逻辑（不修改，确保HandleSensorCodes正常执行）
            // 注意：传入“有效ID拼接的字符串”，而非原始空数据（避免无效字符）
            string dataToProcess = validSensorIds.Count > 0
                ? string.Join("|", validSensorIds)
                : string.Empty; // 无有效ID时传空字符串，触发清空逻辑
            HandleSensorCodes(dataToProcess);
            Console.WriteLine($"[Form1-业务触发] 调用HandleSensorCodes，传入数据：{dataToProcess}");
        }

        /// <summary>
        /// （修复空数据UI更新）根据有效ID数量，安全更新UI（空数据时主动清空）
        /// 核心：解决“无数据时旧值残留”问题
        /// 添加旧值检测，避免重复识别
        /// </summary>
        /// <param name="validSensorIds"></param>
        private void UpdateSensorUI(List<string> validSensorIds)
        {
            if (this.InvokeRequired)
            {
                this.Invoke(new Action<List<string>>(UpdateSensorUI), validSensorIds);
                return;
            }

            // 场景1：无有效ID
            if (validSensorIds == null || validSensorIds.Count == 0)
            {
                ClearForm1OldData();
                Console.WriteLine("[SelectRFID-UI更新] 无有效ID，清空input_SensorID1/2");
                return;
            }
            // 场景3：1个有效ID
            if (validSensorIds.Count == 1)
            {

            }
            // 场景3：2个有效ID
            if (validSensorIds.Count == 2)
            {
                // 简化的重复检测：比较新旧ID集合
                var newSet = new HashSet<string>(validSensorIds);
                var oldSet = new HashSet<string> { textBox_RFID1.Text, textBox_RFID2.Text };

                // 如果不是重复识别，则更新UI
                if (!newSet.SetEquals(oldSet))
                {
                    textBox_RFID1.Text = validSensorIds[0];
                    textBox_RFID2.Text = validSensorIds[1];
                    Console.WriteLine($"[SelectRFID-UI更新] 2个有效ID，textBox_RFID1：{validSensorIds[0]}，textBox_RFID2：{validSensorIds[1]}");


                }
                else
                {
                    Console.WriteLine("[SelectRFID-重复识别] 检测到重复ID组合，停止处理");
                    // 重复识别，停止后续处理
                }
            }
        }


        /// <summary>
        /// 解析原始数据，提取有效感应器ID（E开头16位）
        /// </summary>
        /// <param name="rawData"></param>
        /// <returns></returns>
        private List<string> ParseSensorDatas(string rawData)
        {
            List<string> sensors = new List<string>();
            if (string.IsNullOrWhiteSpace(rawData)) return sensors;

            // 清理空白字符
            string cleaned = Regex.Replace(rawData, @"\s+", "");
            // 匹配E开头的16位字符串（E+15位0-9/A-F）
            MatchCollection matches = Regex.Matches(cleaned, @"E[0-9A-F]{15}");

            // 提取前2个有效数据
            foreach (Match m in matches)
            {
                if (sensors.Count < 2)
                {
                    sensors.Add(m.Value);

                }
                else break;
            }


            if (sensors.Count == 0)
            {

            }
            if (sensors.Count == 1)
            {

                textBox_RFID1.Text = sensors[0];

            }

            else
            {
                textBox_RFID1.Text = sensors[0];
                textBox_RFID2.Text = sensors[1];

            }
            return sensors;
        }

        /// <summary>
        /// 处理返回的感应器编码
        /// </summary>
        /// <param name="codes"></param>
        private void HandleSensorCodes(string codes)
        {
            if (codes.Length == 0)
            {

                Console.WriteLine("EClotheForms:未识别到任何感应器");
                return;
            }
            else
            {

                ParseSensorDatas(codes);


            }
        }

        /// <summary>
        /// 辅助方法：从原始推送数据中提取有效传感器ID（复用HFReader的解析规则）
        /// 作用：统一解析逻辑，确保“HFReader认为的有效ID”与“Form1显示的有效ID”一致
        /// （与HFReader内部对齐）提取有效传感器ID（规则完全同步HFReader内部）
        /// 核心：确保外部解析规则与HFReader内部一致，避免“内部有效外部无效”
        /// </summary>
        private List<string> ExtractValidSensorIds(string rawData)
        {
            List<string> validIds = new List<string>();
            if (string.IsNullOrWhiteSpace(rawData))
            {
                Console.WriteLine("[SelectRFID-解析] 原始数据为空，返回空列表（用于清空UI）");
                return validIds; // 空数据时返回空列表，触发UI清空
            }

            // 步骤1：清理原始数据（与HFReader内部清理规则完全一致：移除空格、分号等干扰字符）
            string cleanedData = Regex.Replace(rawData, @"[\s;,]+", "");
            Console.WriteLine($"[SelectRFID-数据清理] 清理后的数据：{cleanedData}");

            // 步骤2：匹配有效ID（使用与HFReader内部相同的正则，忽略大小写）
            MatchCollection matches = Regex.Matches(cleanedData, SensorIdPattern, RegexOptions.IgnoreCase);
            Console.WriteLine($"[SelectRFID-解析] 匹配到{matches.Count}个符合规则的ID");

            // 步骤3：提取最多2个有效ID（与HFReader内部“最多2个传感器”逻辑对齐）
            foreach (Match match in matches)
            {
                if (validIds.Count < 2)
                {
                    string sensorId = match.Value.ToUpperInvariant(); // 统一转为大写（内外一致）
                    validIds.Add(sensorId);
                    Console.WriteLine($"[SelectRFID-有效ID] 新增：{sensorId}，当前列表：{string.Join("|", validIds)}");
                }
                else
                {
                    Console.WriteLine($"[SelectRFID-解析] ID数量超2个，忽略多余ID：{match.Value}");
                    break;
                }
            }

            return validIds;
        }
        /// <summary>
        /// 统一清理Form1旧数据的方法（空数据/Form2关闭/隐藏时调用）
        /// 核心：确保无有效数据时，彻底清空UI和变量旧值
        /// </summary>
        private void ClearForm1OldData()
        {
            // 1. 清空UI控件旧值（覆盖所有显示传感器数据的控件）
            textBox_TagID.Text = string.Empty;
            textBox_RFID1.Text = string.Empty;
            textBox_RFID2.Text = string.Empty;

            Console.WriteLine("[SelectRFID-清理] 已清空UI旧值数据");
        }


        /// <summary>
        /// 根据1个感应器RFID，返回另一个感应器RFID,以及对应的TagID 
        /// </summary>
        /// <param name="RFID">感应器</param>
        public void Select_Tb_Sensor(string RFID)
        {
            // 获取全局SqlSugar实例
            var db = SqlSugarHelper.Db;
            string _clothesGUID = string.Empty;

            try
            {
                // 从数据库查询：根据SensorID获取对应的ClothesGUID（最多1条）
                var resultList = db.Queryable<Tb_Sensor>()
                                   .Where(it => it.SensorID == RFID)
                                   .Select(it => it.ClothesGUID) // 仅查询ClothesGUID字段
                                   .Take(1)                      // 限制最多1条记录
                                   .First();
                _clothesGUID = resultList;

                var clothesInfo = db.Queryable<Tb_Clothes>()
                                    .Where(it => it.GUID == _clothesGUID)
                                    .Select(it => new
                                    {
                                        it.TagID,
                                        it.SensorID1,
                                        it.SensorID2
                                    })
                                   .First();
                if (clothesInfo != null)
                {
                    // 可以直接通过 . 的方式访问属性
                    string tagId = clothesInfo.TagID;
                    string sensorId1 = clothesInfo.SensorID1;
                    string sensorId2 = clothesInfo.SensorID2;

                    Console.WriteLine($"TagID: {tagId}, SensorID1: {sensorId1}, SensorID2: {sensorId2}");
                    textBox_TagID.Text = tagId;
                    textBox_RFID1.Text = sensorId1;
                    textBox_RFID2.Text = sensorId2;

                }
                else
                {
                    Console.WriteLine("未找到对应的衣物信息。");
                }

            }
            catch (Exception ex)
            {

            }


        }


    }
}
